// 手写一个promise函数
// pending初始态  fufilled成功态 rejected失败态
// 使用例子
// const p = new MyPromise((resove,reject)=>{
//   // 异步操作...
//   if(CHENGGONG){
//     resove('成功的原因')
//   }else{
//   reject('失败的原因')
//   }
// })
class MyPromise {
  static PENDING = 'pending'
  static FULFILLED = 'fulfilled'
  static REJECTED = 'rejected'
  
  constructor(executor) {
    // 初始化状态和值
    this.state = MyPromise.PENDING
    this.value = undefined
    this.reason = undefined
    
    // 存储异步情况下的回调函数
    this.onFulfilledCallbacks = [] // 存储成功回调
    this.onRejectedCallbacks = []  // 存储失败回调
    
    // 定义 resolve 函数
    const resolve = (value) => {
      // 只有在 pending 状态才能改变状态
      if (this.state === MyPromise.PENDING) {
        this.state = MyPromise.FULFILLED
        this.value = value
        // 执行所有存储的成功回调
        this.onFulfilledCallbacks.forEach(callback => callback())
      }
    }
    
    // 定义 reject 函数
    const reject = (reason) => {
      // 只有在 pending 状态才能改变状态
      if (this.state === MyPromise.PENDING) {
        this.state = MyPromise.REJECTED
        this.reason = reason
        // 执行所有存储的失败回调
        this.onRejectedCallbacks.forEach(callback => callback())
      }
    }
    
    // 执行传入的函数，并捕获异常
    try {
      executor(resolve, reject)
    } catch (error) {
      reject(error)
    }
  }
  
  // then 方法 - 第二版：返回新的 Promise
  then(onFulfilled, onRejected) {
    // 参数检查：如果不是函数，就用默认函数
    onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value
    onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason }
    
    // 返回新的 Promise 实现链式调用
    return new MyPromise((resolve, reject) => {
      // 根据当前状态决定如何处理
      if (this.state === MyPromise.FULFILLED) {
        // 如果已经成功，调用成功回调
        try {
          const result = onFulfilled(this.value)
          console.log('同步成功回调结果:', result)
          resolve(result) // 将回调结果传给新的 Promise
        } catch (error) {
          console.log('同步成功回调出错:', error)
          reject(error) // 如果回调出错，新的 Promise 变为 rejected
        }
      }
      
      if (this.state === MyPromise.REJECTED) {
        // 如果已经失败，调用失败回调
        try {
          const result = onRejected(this.reason)
          console.log('同步失败回调结果:', result)
          resolve(result) // 注意：失败回调正常执行后，新的 Promise 是 fulfilled
        } catch (error) {
          console.log('同步失败回调出错:', error)
          reject(error) // 如果失败回调也出错，新的 Promise 仍然是 rejected
        }
      }
      
      if (this.state === MyPromise.PENDING) {
        // 如果还在等待中，将回调函数存储起来
        console.log('Promise 还在 pending 状态，存储回调函数')
        
        // 存储成功回调
        this.onFulfilledCallbacks.push(() => {
          try {
            const result = onFulfilled(this.value)
            console.log('异步成功回调结果:', result)
            resolve(result)
          } catch (error) {
            console.log('异步成功回调出错:', error)
            reject(error)
          }
        })
        
        // 存储失败回调
        this.onRejectedCallbacks.push(() => {
          try {
            const result = onRejected(this.reason)
            console.log('异步失败回调结果:', result)
            resolve(result)
          } catch (error) {
            console.log('异步失败回调出错:', error)
            reject(error)
          }
        })
      }
    })
  }
  
  // catch 方法 - 专门处理失败情况
  catch(onRejected) {
    // catch 其实就是只传第二个参数的 then
    return this.then(null, onRejected)
  }
  
  // finally 方法 - 无论成功失败都会执行
  finally(onFinally) {
    return this.then(
      // 成功时：执行finally回调，然后传递原值
      value => {
        return MyPromise.resolve(onFinally()).then(() => value)
      },
      // 失败时：执行finally回调，然后重新抛出错误  
      reason => {
        return MyPromise.resolve(onFinally()).then(() => { throw reason })
      }
    )
  }
  
  // 静态方法：resolve - 创建一个成功的Promise
  static resolve(value) {
    // 如果传入的已经是Promise，直接返回
    if (value instanceof MyPromise) {
      return value
    }
    // 否则创建一个新的成功Promise
    return new MyPromise(resolve => resolve(value))
  }
  
  // 静态方法：reject - 创建一个失败的Promise
  static reject(reason) {
    return new MyPromise((resolve, reject) => reject(reason))
  }
  
  // 静态方法：all - 所有Promise都成功时才成功
  static all(promises) {
    return new MyPromise((resolve, reject) => {
      // 处理空数组的情况
      if (!Array.isArray(promises)) {
        return reject(new TypeError('参数必须是数组'))
      }
      
      if (promises.length === 0) {
        return resolve([])
      }
      
      const results = new Array(promises.length) // 预分配数组
      let completedCount = 0
      
      promises.forEach((promise, index) => {
        // 确保每个元素都是Promise
        MyPromise.resolve(promise).then(
          value => {
            results[index] = value
            completedCount++
            
            // 所有Promise都完成时resolve
            if (completedCount === promises.length) {
              resolve(results)
            }
          },
          reason => {
            // 任何一个失败就立即reject
            reject(reason)
          }
        )
      })
    })
  }
  
  // 静态方法：race - 第一个完成的Promise决定结果
  static race(promises) {
    return new MyPromise((resolve, reject) => {
      if (!Array.isArray(promises)) {
        return reject(new TypeError('参数必须是数组'))
      }
      
      // 空数组的话永远不会resolve或reject
      promises.forEach(promise => {
        MyPromise.resolve(promise).then(resolve, reject)
      })
    })
  }
  
  // 静态方法：allSettled - 等待所有Promise完成（无论成功失败）
  static allSettled(promises) {
    return new MyPromise(resolve => {
      if (!Array.isArray(promises)) {
        return resolve([])
      }
      
      if (promises.length === 0) {
        return resolve([])
      }
      
      const results = new Array(promises.length)
      let completedCount = 0
      
      promises.forEach((promise, index) => {
        MyPromise.resolve(promise).then(
          value => {
            results[index] = { status: 'fulfilled', value }
            completedCount++
            
            if (completedCount === promises.length) {
              resolve(results)
            }
          },
          reason => {
            results[index] = { status: 'rejected', reason }
            completedCount++
            
            if (completedCount === promises.length) {
              resolve(results)
            }
          }
        )
      })
    })
  }
}

// // 测试第二步：then 方法（同步情况）
// console.log('\n=== 第二步测试：then 方法（同步） ===')

// const p4 = new MyPromise((resolve, reject) => {
//   resolve('成功的值')
// })

// console.log('调用 then 方法:')
// const result1 = p4.then(
//   value => {
//     console.log('成功回调被调用，接收到:', value)
//     return '处理后的值'
//   },
//   reason => {
//     console.log('失败回调被调用，接收到:', reason)
//     return '处理后的错误'
//   }
// )

// console.log('then 方法返回:', result1)

// // 测试 reject 情况
// console.log('\n--- 测试 reject 情况 ---')
// const p5 = new MyPromise((resolve, reject) => {
//   reject('失败的原因')
// })

// const result2 = p5.then(
//   value => {
//     console.log('成功回调（不应该执行）:', value)
//     return '成功处理'
//   },
//   reason => {
//     console.log('失败回调被调用，接收到:', reason)
//     return '错误已处理'
//   }
// )

// console.log('reject情况 then 方法返回:', result2)

// // 测试链式调用
// console.log('\n--- 测试链式调用 ---')
// const p6 = new MyPromise((resolve, reject) => {
//   resolve(10)
// })

// p6.then(value => {
//   console.log('第一个then，接收到:', value)
//   return value * 2
// }).then(value => {
//   console.log('第二个then，接收到:', value)
//   return value + 5
// }).then(value => {
//   console.log('第三个then，接收到:', value)
//   return '最终结果: ' + value
// }).then(finalValue => {
//   console.log('链式调用最终结果:', finalValue)
// })

// // 测试第三步：异步操作
// console.log('\n=== 第三步测试：异步操作 ===')

// // 异步 resolve
// console.log('创建异步 Promise（1秒后resolve）')
// const asyncPromise1 = new MyPromise((resolve, reject) => {
//   console.log('开始异步操作...')
//   setTimeout(() => {
//     console.log('1秒后，异步操作完成')
//     resolve('异步成功的结果')
//   }, 1000)
// })

// console.log('立即调用 then 方法（此时Promise还在pending）')
// asyncPromise1.then(value => {
//   console.log('异步成功回调执行:', value)
//   return value + ' - 已处理'
// }).then(value => {
//   console.log('异步链式调用:', value)
// })

// // 异步 reject
// console.log('\n--- 异步 reject 测试 ---')
// const asyncPromise2 = new MyPromise((resolve, reject) => {
//   setTimeout(() => {
//     console.log('0.5秒后，异步操作失败')
//     reject('异步失败的原因')
//   }, 500)
// })

// asyncPromise2.then(
//   value => {
//     console.log('成功回调（不应该执行）:', value)
//   },
//   reason => {
//     console.log('异步失败回调执行:', reason)
//     return '错误已处理'
//   }
// ).then(value => {
//   console.log('失败后的链式调用:', value)
// })

// // 测试多个 then 回调
// console.log('\n--- 测试多个then回调 ---')
// const multiPromise = new MyPromise((resolve, reject) => {
//   setTimeout(() => {
//     console.log('2秒后resolve')
//     resolve('多回调测试')
//   }, 2000)
// })

// // 添加多个 then 回调
// multiPromise.then(value => {
//   console.log('第1个then回调:', value)
// })

// multiPromise.then(value => {
//   console.log('第2个then回调:', value)
// })

// multiPromise.then(value => {
//   console.log('第3个then回调:', value)
// })

// console.log('所有同步代码执行完毕，等待异步结果...')

// // === 异步原理解释 ===
// console.log('\n=== 异步原理解释 ===')

// console.log('1. 开始执行同步代码')

// // 创建一个简单的异步示例
// let savedCallback = null  // 这就是我们存储回调的机制

// console.log('2. 创建异步操作')
// setTimeout(() => {
//   console.log('4. 异步操作完成，现在执行存储的回调')
//   if (savedCallback) {
//     savedCallback('异步结果')
//   }
// }, 100)

// console.log('3. 存储回调函数')
// savedCallback = (result) => {
//   console.log('5. 回调被执行，收到结果:', result)
// }

// console.log('6. 同步代码执行完毕，等待异步...')

// // === 用我们的Promise解释异步原理 ===
// console.log('\n=== 用我们的Promise解释异步原理 ===')

// console.log('步骤1: 创建Promise，开始异步操作')
// const explainPromise = new MyPromise((resolve, reject) => {
//   console.log('步骤2: executor立即执行（同步）')
//   console.log('步骤3: 启动setTimeout（异步）')
//   setTimeout(() => {
//     console.log('步骤6: 异步操作完成，调用resolve')
//     resolve('异步操作的结果')
//   }, 200)
//   console.log('步骤4: executor执行完毕，Promise状态为pending')
// })

// console.log('步骤5: 调用then方法')
// explainPromise.then(value => {
//   console.log('步骤7: then回调执行，收到:', value)
// })

// console.log('步骤8: 所有同步代码执行完毕')
// console.log('现在等待异步操作完成...')

// // === 核心问题解答：为什么同步文件能处理异步？ ===
// console.log('\n=== 🔍 核心问题解答 ===')

// console.log('❌ 误解：认为我们创造了异步')
// console.log('✅ 真相：我们只是管理JavaScript本身的异步API')

// console.log('\n--- 证明：JavaScript本身就有异步能力 ---')
// console.log('A. 开始执行同步代码')

// // JavaScript原生就有的异步API
// setTimeout(() => {
//   console.log('C. 这是JavaScript原生的异步能力（不是我们创造的）')
// }, 50)

// console.log('B. 同步代码继续执行')

// console.log('\n--- 我们的Promise只是协调工具 ---')

// // 不用Promise的异步代码
// console.log('1. 不用Promise的原始异步:')
// let callback1 = null
// setTimeout(() => {
//   console.log('3. 原始异步完成，手动调用回调')
//   if (callback1) callback1('原始异步结果')
// }, 100)

// callback1 = (result) => {
//   console.log('4. 原始异步回调执行:', result)
// }

// console.log('2. 回调已设置，等待异步完成')

// // 使用我们的Promise
// console.log('\n5. 使用我们的Promise包装相同的异步操作:')
// const ourPromise = new MyPromise((resolve) => {
//   setTimeout(() => {  // 还是相同的JavaScript异步API
//     console.log('7. Promise异步完成')
//     resolve('Promise异步结果')
//   }, 150)
// })

// ourPromise.then(result => {
//   console.log('8. Promise回调执行:', result)
// })

// console.log('6. Promise已创建，等待异步完成')

// // 测试第一步实现
// console.log('=== 第一步测试：基础构造函数 ===')

// // 测试同步 resolve
// const p1 = new MyPromise((resolve, reject) => {
//   resolve('同步成功')
// })
// console.log('同步resolve:', p1.state, p1.value)

// // 测试同步 reject
// const p2 = new MyPromise((resolve, reject) => {
//   reject('同步失败')
// })
// console.log('同步reject:', p2.state, p2.reason)

// // 测试异常捕获
// const p3 = new MyPromise((resolve, reject) => {
//   throw new Error('抛出异常')
// })
// console.log('异常捕获:', p3.state, p3.reason.message)

// === Class 常量定义方式演示 ===
console.log('\n=== 🔧 Class 常量定义方式 ===')

class ConstantDemo {
  // 方式1: 静态属性（我们目前用的）
  static STATUS_PENDING = 'pending'
  static STATUS_SUCCESS = 'success'
  static MAX_RETRY = 3
  
  // 方式2: 静态getter（真正的只读）
  static get API_URL() {
    return 'https://api.example.com'
  }
  
  static get VERSION() {
    return '1.0.0'
  }
  
  // 方式3: 私有静态属性（ES2022+）
  static #SECRET_KEY = 'super-secret'
  
  static getSecretKey() {
    return this.#SECRET_KEY
  }
  
  constructor() {
    // 方式4: 实例常量（每个实例都有）
    this.INSTANCE_ID = Math.random().toString(36)
    
    // 方式5: 使用Object.freeze创建真正的常量
    this.CONFIG = Object.freeze({
      timeout: 5000,
      retries: 3,
      debug: true
    })
  }
  
  // 方式6: 实例getter（每个实例的只读属性）
  get DEFAULT_TIMEOUT() {
    return 30000
  }
}

// 测试各种常量定义方式
console.log('1. 静态属性（类级别常量）:')
console.log('  STATUS_PENDING:', ConstantDemo.STATUS_PENDING)
console.log('  MAX_RETRY:', ConstantDemo.MAX_RETRY)

console.log('\n2. 静态getter（只读）:')
console.log('  API_URL:', ConstantDemo.API_URL)
console.log('  VERSION:', ConstantDemo.VERSION)

console.log('\n3. 私有静态属性:')
console.log('  SECRET_KEY:', ConstantDemo.getSecretKey())
// console.log('  直接访问私有属性会报错:', ConstantDemo.#SECRET_KEY) // 这行会报错

console.log('\n4. 实例常量:')
const demo1 = new ConstantDemo()
const demo2 = new ConstantDemo()
console.log('  demo1.INSTANCE_ID:', demo1.INSTANCE_ID)
console.log('  demo2.INSTANCE_ID:', demo2.INSTANCE_ID)

console.log('\n5. 冻结对象（真正不可变）:')
console.log('  demo1.CONFIG:', demo1.CONFIG)
// demo1.CONFIG.timeout = 10000 // 这不会生效，因为对象被冻结了
console.log('  尝试修改后:', demo1.CONFIG.timeout) // 还是 5000

console.log('\n6. 实例getter:')
console.log('  demo1.DEFAULT_TIMEOUT:', demo1.DEFAULT_TIMEOUT)

// === 核心问题解答：为什么pending状态要存储回调？ ===
console.log('\n=== 🤔 为什么pending状态要存储回调？ ===')

console.log('让我们模拟一个错误的写法来理解：')

// 错误的写法演示
class WrongPromise {
  constructor(executor) {
    this.state = 'pending'
    this.value = undefined
    
    const resolve = (value) => {
      this.state = 'fulfilled'
      this.value = value
      console.log('  resolve被调用，状态改为fulfilled，值为:', value)
    }
    
    executor(resolve)
  }
  
  then(onFulfilled) {
    console.log('  then被调用，当前状态:', this.state, '当前值:', this.value)
    
    if (this.state === 'pending') {
      console.log('  ❌ 错误写法：直接调用回调')
      // 错误：直接调用回调，但这时value还是undefined
      const result = onFulfilled(this.value) // value还是undefined！
      console.log('  回调执行结果:', result)
    }
  }
}

console.log('\n--- 错误示例：直接调用回调 ---')
console.log('1. 创建异步Promise')
const wrongPromise = new WrongPromise((resolve) => {
  console.log('2. executor开始执行')
  setTimeout(() => {
    console.log('4. 1秒后异步操作完成')
    resolve('异步结果')
  }, 1000)
  console.log('3. executor结束，Promise状态为pending')
})

console.log('5. 立即调用then（此时还是pending状态）')
wrongPromise.then(value => {
  console.log('6. 回调收到的值:', value) // 这里会是undefined！
  return '处理后的值'
})

console.log('7. then调用完毕，等待异步操作...')

// 正确的写法演示
console.log('\n--- 正确示例：存储回调 ---')

class CorrectPromise {
  constructor(executor) {
    this.state = 'pending'
    this.value = undefined
    this.callbacks = [] // 存储回调
    
    const resolve = (value) => {
      this.state = 'fulfilled'
      this.value = value
      console.log('  resolve被调用，状态改为fulfilled，值为:', value)
      // 执行所有存储的回调
      this.callbacks.forEach(callback => callback())
    }
    
    executor(resolve)
  }
  
  then(onFulfilled) {
    console.log('  then被调用，当前状态:', this.state, '当前值:', this.value)
    
    if (this.state === 'pending') {
      console.log('  ✅ 正确写法：存储回调，等待resolve时执行')
      // 正确：存储回调函数，等resolve调用时再执行
      this.callbacks.push(() => {
        const result = onFulfilled(this.value) // 这时value已经有值了！
        console.log('  存储的回调被执行，收到值:', this.value, '处理结果:', result)
      })
    }
  }
}

console.log('\n8. 创建正确的异步Promise')
const correctPromise = new CorrectPromise((resolve) => {
  console.log('9. executor开始执行')
  setTimeout(() => {
    console.log('12. 1秒后异步操作完成，调用resolve')
    resolve('正确的异步结果')
    console.log('13. resolve执行完毕，存储的回调已被调用')
  }, 1500)
  console.log('10. executor结束，Promise状态为pending')
})

console.log('11. 立即调用then（此时还是pending状态）')
correctPromise.then(value => {
  console.log('14. 回调收到的值:', value) // 这里会是正确的值！
  return '正确处理后的值'
})

// 时间线对比
console.log('\n=== ⏰ 时间线对比 ===')
console.log('错误写法时间线:')
console.log('  T0: 创建Promise → pending状态，value=undefined')
console.log('  T1: 调用then → 立即执行回调 → 收到undefined ❌')
console.log('  T2: resolve被调用 → 改变状态和值 → 但回调已经执行过了')

console.log('\n正确写法时间线:')
console.log('  T0: 创建Promise → pending状态，value=undefined')
console.log('  T1: 调用then → 存储回调函数 → 等待resolve')
console.log('  T2: resolve被调用 → 改变状态和值 → 执行存储的回调 → 收到正确值 ✅')

// === 测试新增的Promise方法 ===
console.log('\n=== 🎯 测试Promise的其他方法 ===')

// 1. 测试 catch 方法
console.log('\n--- 1. 测试 catch 方法 ---')
MyPromise.reject('出错了').catch(error => {
  console.log('catch捕获到错误:', error)
  return '错误已处理'
}).then(value => {
  console.log('catch后的then:', value)
})

// 2. 测试 finally 方法
console.log('\n--- 2. 测试 finally 方法 ---')
MyPromise.resolve('成功').finally(() => {
  console.log('finally: 无论成功失败都会执行')
}).then(value => {
  console.log('finally后的值:', value) // 还是原来的值
})

MyPromise.reject('失败').finally(() => {
  console.log('finally: 失败情况下也会执行')
}).catch(reason => {
  console.log('finally后的错误:', reason) // 还是原来的错误
})

// 3. 测试静态方法 resolve 和 reject
console.log('\n--- 3. 测试静态方法 ---')
MyPromise.resolve('静态resolve').then(value => {
  console.log('静态resolve结果:', value)
})

MyPromise.reject('静态reject').catch(reason => {
  console.log('静态reject结果:', reason)
})

// 4. 测试 Promise.all
console.log('\n--- 4. 测试 Promise.all ---')
const promise1 = MyPromise.resolve(1)
const promise2 = MyPromise.resolve(2)
const promise3 = new MyPromise(resolve => {
  setTimeout(() => resolve(3), 100)
})

MyPromise.all([promise1, promise2, promise3]).then(values => {
  console.log('Promise.all结果:', values) // [1, 2, 3]
})

// 测试 Promise.all 中有失败的情况
const failPromise = MyPromise.reject('all中的错误')
MyPromise.all([promise1, failPromise, promise3]).catch(reason => {
  console.log('Promise.all失败:', reason) // 'all中的错误'
})

// 5. 测试 Promise.race
console.log('\n--- 5. 测试 Promise.race ---')
const fast = new MyPromise(resolve => {
  setTimeout(() => resolve('我很快'), 50)
})
const slow = new MyPromise(resolve => {
  setTimeout(() => resolve('我很慢'), 200)
})

MyPromise.race([fast, slow]).then(value => {
  console.log('Promise.race结果:', value) // '我很快'
})

// 6. 测试 Promise.allSettled
console.log('\n--- 6. 测试 Promise.allSettled ---')
const successPromise = MyPromise.resolve('成功')
const failPromise2 = MyPromise.reject('失败')
const asyncPromise = new MyPromise(resolve => {
  setTimeout(() => resolve('异步成功'), 150)
})

MyPromise.allSettled([successPromise, failPromise2, asyncPromise]).then(results => {
  console.log('Promise.allSettled结果:')
  results.forEach((result, index) => {
    if (result.status === 'fulfilled') {
      console.log(`  [${index}] 成功:`, result.value)
    } else {
      console.log(`  [${index}] 失败:`, result.reason)
    }
  })
})

console.log('\n=== 🎉 Promise实现完成！ ===')
console.log('我们的MyPromise现在支持:')
console.log('✅ 基础功能: 构造函数、状态管理、异步处理')
console.log('✅ 实例方法: then、catch、finally')
console.log('✅ 静态方法: resolve、reject、all、race、allSettled')
console.log('✅ 链式调用和错误处理')
console.log('等待异步结果输出...')